home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpat2-1.000 / xpat2-1 / xpat2-1.04 / src / X-markcard.c < prev    next >
C/C++ Source or Header  |  1994-09-24  |  7KB  |  199 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    X patience version 2 -- module X-markcard.c                 */
  5. /*                                         */
  6. /*    Routines for marking selected cards                     */
  7. /*    written by Heiko Eissfeldt and Michael Bischoff                 */
  8. /*    see COPYRIGHT.xpat2 for Copyright details                 */
  9. /*                                         */
  10. /*                                         */
  11. /*****************************************************************************/
  12. #include "X-pat.h"
  13.  
  14. #ifndef NO_ROUND_CARDS
  15. #include    <X11/Xmu/Drawing.h>
  16. #endif
  17.  
  18.  
  19. #include "stipple.bm"
  20.  
  21. /* game.for set-mark / clear-mark */
  22.  
  23. static GC dashedlinegc;
  24. static GC whitelinegc;
  25. static GC stipplegc;
  26. static int LINEWIDTH = 3;
  27. static Pixmap mark_storage_x = 0;
  28. static int mark_height = 0, mark_width = 0;
  29. static Pixmap mark_storage_y;
  30.  
  31. static int rem_x, rem_y;
  32. static XSize_t rem_w, rem_h;       /* h = 0: only horizontal bars saved */
  33.  
  34. void init_mark(unsigned long pixel, int markwidth) {
  35.     /* make GCs for dashed lines or colored lines (to mark cards) */
  36.     XGCValues gcv;
  37.     long gcflags;
  38.     Pixmap stipplemap;
  39.  
  40.     if (2 * markwidth > CARD_WIDTH)
  41.     markwidth = (CARD_WIDTH+1) >> 1;
  42.     LINEWIDTH = markwidth;
  43.     /* make own gcs for dashed lines */
  44.     gcv.background = WhitePixel(dpy, screen);
  45.     gcv.graphics_exposures = True;
  46.     gcflags = GCForeground | GCBackground | GCGraphicsExposures;
  47.     if (graphic.is_color && pixel != BlackPixel(dpy, screen)) {
  48.     gcv.foreground = pixel;
  49.     dashedlinegc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  50.     XSetLineAttributes(dpy, dashedlinegc, LINEWIDTH, LineSolid, CapButt, JoinMiter);
  51.     } else {
  52.     gcv.foreground = BlackPixel(dpy, screen);
  53.     dashedlinegc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  54.     XSetLineAttributes(dpy, dashedlinegc, LINEWIDTH, LineOnOffDash, CapButt, JoinMiter);
  55.     }
  56.     gcv.foreground = WhitePixel(dpy, screen);
  57.     gcv.background = BlackPixel(dpy, screen);
  58.     gcv.graphics_exposures = True;
  59.     gcflags = GCForeground | GCBackground | GCGraphicsExposures;
  60.     whitelinegc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  61.  
  62.     XSetLineAttributes(dpy, whitelinegc, LINEWIDTH, LineSolid, CapButt, JoinMiter);
  63.     stipplemap = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  64.                        stipple_bits, stipple_width, stipple_height);
  65.     gcflags = GCForeground | /* GCBackground | */ GCGraphicsExposures |
  66.     GCFillStyle | GCStipple;
  67.     gcv.foreground = BlackPixel(dpy, screen);
  68.     gcv.background = WhitePixel(dpy, screen);
  69.     gcv.stipple = stipplemap;
  70.     gcv.fill_style = FillStippled;
  71.     stipplegc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  72. }
  73.  
  74. static void set_mark(int x, int y, XSize_t W, XSize_t h) {
  75.     if (h > mark_height) {    /* make sure there's enough space */
  76.     XFreePixmap(dpy, mark_storage_y);
  77.     mark_height = h;
  78.         mark_storage_y = XCreatePixmap(dpy, table, 2 * LINEWIDTH, mark_height,
  79.         DefaultDepth(dpy, screen));
  80.     }
  81.     if (W > mark_width) {
  82.     XFreePixmap(dpy, mark_storage_x);
  83.     mark_width = W;
  84.         mark_storage_x = XCreatePixmap(dpy, table, W, 2 * LINEWIDTH,
  85.         DefaultDepth(dpy, screen));
  86.     }
  87.  
  88.     if (2 * LINEWIDTH >= W) {    /* rectangle operation */
  89.     rem_h = h;
  90.     rem_w = W;
  91.     rem_x = x;
  92.     rem_y = y;
  93.     XCopyArea(dpy, table, mark_storage_y, whitegc, x, y,
  94.         rem_w, rem_h, 0, 0);
  95. #ifndef NO_ROUND_CARDS
  96.     if (ROUND_W)
  97.         XmuFillRoundedRectangle(dpy, table, stipplegc, x, y,
  98.         rem_w, rem_h, ROUND_W, ROUND_H);
  99.     else
  100. #endif
  101.         XFillRectangle(dpy, table, stipplegc, x, y, rem_w, rem_h);
  102.     XFlush(dpy);
  103.     return;
  104.     }
  105.  
  106.     rem_h = h - 2 * LINEWIDTH;
  107.     if (h <= 0)        /* do not mark thin areas */
  108.     return;
  109.     rem_w = W;
  110.     rem_x = x;
  111.     rem_y = y;
  112.     
  113.     XCopyArea(dpy, table, mark_storage_x, whitegc, x, y,
  114.           rem_w, LINEWIDTH, 0, 0);
  115.     XCopyArea(dpy, table, mark_storage_x, whitegc, x, y+h-LINEWIDTH,
  116.           rem_w, LINEWIDTH, 0, LINEWIDTH);
  117.     if (rem_h > 0) {
  118.     XCopyArea(dpy, table, mark_storage_y, whitegc, x, y+LINEWIDTH,
  119.           LINEWIDTH, rem_h, 0, 0);
  120.     XCopyArea(dpy, table, mark_storage_y, whitegc, x+W-LINEWIDTH, y+LINEWIDTH,
  121.           LINEWIDTH, rem_h, LINEWIDTH, 0);
  122.     }
  123.     if (!ROUND_H) {        /* this variant does not look very pretty for round cards */
  124.     XPoint r[5];
  125.     r[0].x = r[3].x = r[4].x = x + LINEWIDTH/2;
  126.     r[1].x = r[2].x = x + W - (LINEWIDTH+1)/2;
  127.     r[0].y = r[1].y = r[4].y = y + LINEWIDTH/2;
  128.     r[2].y = r[3].y = y + h - (LINEWIDTH+1)/2;
  129.     /* XDrawLines(dpy, table, whitelinegc,  r, 5, CoordModeOrigin); */
  130.     XDrawLines(dpy, table, dashedlinegc, r, 5, CoordModeOrigin);
  131.     } else {
  132.     int d, e, i, w, o;
  133.     static GC *gc1tab[2] = { &dashedlinegc, &whitelinegc };
  134.     
  135.     h -= (LINEWIDTH+1)/2;    /* correct values for DrawLine */
  136.     w = W - (LINEWIDTH+1)/2;
  137.     d = ROUND_W;
  138.     e = ROUND_H;
  139.     o = LINEWIDTH / 2;
  140.     for (i = 0; i >= 0; --i) {
  141.         XDrawLine(dpy, table, *gc1tab[i], x+o+d, y+o,   x+w-d, y+o); 
  142.         XDrawLine(dpy, table, *gc1tab[i], x+o+d, y+h,   x+w-d, y+h); 
  143.         XDrawLine(dpy, table, *gc1tab[i], x+o,   y+o+e, x+o,   y+h-e); 
  144.         XDrawLine(dpy, table, *gc1tab[i], x+w,   y+o+e, x+w,   y+h-e); 
  145.     }
  146.     }
  147.     XFlush(dpy);
  148. }
  149.  
  150. static void clear_mark(void) {
  151.     if (2 * LINEWIDTH >= rem_w) {    /* rectangle operation */
  152.     XCopyArea(dpy, mark_storage_y, table, whitegc, 0, 0,
  153.         rem_w, rem_h, rem_x, rem_y);
  154.     } else {
  155.     XCopyArea(dpy, mark_storage_x, table, whitegc, 0, 0,
  156.         rem_w, LINEWIDTH, rem_x, rem_y);
  157.     XCopyArea(dpy, mark_storage_x, table, whitegc, 0, LINEWIDTH,
  158.             rem_w, LINEWIDTH, rem_x, rem_y+rem_h+LINEWIDTH);
  159.     if (rem_h > 0) {
  160.         XCopyArea(dpy, mark_storage_y, table, whitegc, 0, 0,
  161.             LINEWIDTH, rem_h, rem_x, rem_y+LINEWIDTH);
  162.         XCopyArea(dpy, mark_storage_y, table, whitegc, LINEWIDTH, 0,
  163.             LINEWIDTH, rem_h, rem_x+CARD_WIDTH-LINEWIDTH, rem_y+LINEWIDTH);
  164.     }
  165.     }
  166.     XFlush(dpy);
  167. }
  168.  
  169. /* pile is completely drawn and unmarked. */
  170. /* check, if pile has to be marked.       */
  171. /* if so, do it                           */
  172.  
  173. void show_mark(boolean on) {
  174.     if (!game.graphic)
  175.     return;
  176.     if (!mark_storage_x) {
  177.     mark_storage_x = XCreatePixmap(dpy, table, CARD_WIDTH, 2 * LINEWIDTH,
  178.                    DefaultDepth(dpy, screen));
  179.     mark_storage_y = XCreatePixmap(dpy, table, 2 * LINEWIDTH, graphic.height,
  180.                    DefaultDepth(dpy, screen));
  181.     mark_height = graphic.height;
  182.     mark_width = CARD_WIDTH;
  183.     }
  184.     if (on) {
  185.     struct pile *p;
  186.     int f, l;
  187.     int pile;
  188.      if (game.srcind < 0)
  189.         return;
  190.     p = graphic.pile + (pile = getpile(game.srcind));
  191.     f = game.srcind - INDEX_OF_FIRST_CARD(pile);
  192.     l = CARDS_ON_PILE(pile)-1;
  193.     set_mark(p->x + f*p->xdelta, p->y + f * p->delta,
  194.          (l-f)*p->xdelta + CARD_WIDTH, (l-f) * p->delta + CARD_HEIGHT);
  195.     } else {
  196.     clear_mark();
  197.     }
  198. }
  199.